home *** CD-ROM | disk | FTP | other *** search
/ Computer Shopper 242 / Issue 242 - April 2008 - DPCS0408DVD.ISO / Software Money Savers / VirtualDub / Source / VirtualDub-1.7.7-src.7z / src / disasm / main.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2006-11-16  |  6.0 KB  |  283 lines
  1. //    disasm - Disassembly module compiler for VirtualDub
  2. //    Copyright (C) 2002 Avery Lee, All Rights Reserved
  3. //
  4. //    This program is free software; you can redistribute it and/or modify
  5. //    it under the terms of the GNU General Public License as published by
  6. //    the Free Software Foundation; either version 2 of the License, or
  7. //    (at your option) any later version.
  8. //
  9. //    This program is distributed in the hope that it will be useful,
  10. //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. //    GNU General Public License for more details.
  13. //
  14. //    You should have received a copy of the GNU General Public License
  15. //    along with this program; if not, write to the Free Software
  16. //    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  
  18. #pragma warning(disable: 4786)
  19.  
  20. #include <string>
  21. #include <list>
  22. #include <vector>
  23. #include <set>
  24. #include <utility>
  25. #include <algorithm>
  26.  
  27. #include <stdio.h>
  28. #include <string.h>
  29. #include <stdarg.h>
  30. #include <ctype.h>
  31. #include <conio.h>
  32. #include <crtdbg.h>
  33. #include <windows.h>
  34.  
  35. #include "ruleset.h"
  36. #include "utils.h"
  37. #include "runtime_dasm.h"
  38. #include "runtime_tracedec.h"
  39.  
  40. void parse_ia(tRuleSystem& rsys, FILE *f);
  41.  
  42. tRuleSystem        g_RuleSystem;
  43.  
  44. void *VDDisasmDecompress(void *_dst, const unsigned char *src, int src_len);
  45. void *VDTracedecDecompress(void *_dst, const unsigned char *src, int src_len);
  46. bool VDTraceObjectCode(VDTracedecContext *pvdc, const uint8 *source, int bytes, VDTracedecResult& res);
  47. void dump_ia(std::vector<char>& dst, const tRuleSystem& rulesys);
  48. void dump_tracedec(std::vector<char>& dst, const tRuleSystem& rulesys);
  49.  
  50. ///////////////////////////////////////////////////////////////////////////
  51.  
  52. #ifdef _M_AMD64
  53. static const char test1[]={
  54.     0x50,
  55.     0x51,
  56.     0x52,
  57.     0x53,
  58.     0x54,
  59.     0x55,
  60.     0x56,
  61.     0x57,
  62.  
  63.     0x48, 0x50,
  64.     0x4c, 0x50,
  65.     0x4a, 0x50,
  66.     0x49, 0x50,
  67.  
  68.     0x66, 0x44, 0x50,
  69.     0x66, 0x42, 0x50,
  70.     0x66, 0x41, 0x50,
  71.  
  72.     0x58,
  73.     0x59,
  74.     0x5a,
  75.     0x5b,
  76.     0x5c,
  77.     0x5d,
  78.     0x5e,
  79.     0x5f,
  80. };
  81. #else
  82. void __declspec(naked) test1() {
  83.     __asm {
  84.         __emit 0x83
  85.         __emit 0xc3
  86.         __emit 0x01
  87.  
  88.         __emit 0x0f
  89.         __emit 0x18
  90.         __emit 0x05
  91.         __emit 0x40
  92.         __emit 0x07
  93.         __emit 0x90
  94.         __emit 0x02
  95.  
  96.         prefetchnta [eax]
  97.         prefetcht0 [eax]
  98.         prefetcht1 [eax]
  99.         prefetcht2 [eax]
  100.  
  101.         pavgusb        mm0,[eax]
  102.         prefetch    [eax]
  103.         prefetchw    [eax]
  104.         pswapd        mm1, mm0
  105.         push        [eax]
  106.         push        word ptr [eax]
  107.  
  108.         cvtsi2ss    xmm4, ecx
  109.         cvtsi2ss    xmm4, [ecx]
  110.         cvtpi2ps    xmm4, mm2
  111.         cvtpi2ps    xmm4, [ecx]
  112.  
  113.         cvtss2si    eax, xmm4
  114.         cvtss2si    eax, [ecx]
  115.         cvtps2pi    mm2, xmm4
  116.         cvtps2pi    mm2, [ecx]
  117.  
  118.         cvttss2si    eax, xmm4
  119.         cvttss2si    eax, [ecx]
  120.         cvttps2pi    mm2, xmm4
  121.         cvttps2pi    mm2, [ecx]
  122.  
  123.         cvtsi2sd    xmm4, ecx
  124.         cvtsi2sd    xmm4, [ecx]
  125.         cvtpi2pd    xmm4, mm2
  126.         cvtpi2pd    xmm4, [ecx]
  127.  
  128.         cvtsd2si    eax, xmm4
  129.         cvtsd2si    eax, [ecx]
  130.         cvtpd2pi    mm2, xmm4
  131.         cvtpd2pi    mm2, [ecx]
  132.  
  133.         cvttsd2si    eax, xmm4
  134.         cvttsd2si    eax, [ecx]
  135.         cvttpd2pi    mm2, xmm4
  136.         cvttpd2pi    mm2, [ecx]
  137.  
  138.         movq        xmm0, qword ptr [eax]
  139.  
  140. __emit 0x66
  141. __emit 0x0f
  142. __emit 0x6f
  143. __emit 0x2d
  144. __emit 0xf0
  145. __emit 0x42
  146. __emit 0x0e
  147. __emit 0x10
  148.  
  149.         rep movsw
  150.         lock rep movs es:word ptr [edi], cs:word ptr [esi]
  151.  
  152.         lock mov cs:dword ptr [eax+ecx*4+12300000h], 12345678h
  153.  
  154.         __emit 0x2e
  155.         jc x1
  156.  
  157.         __emit 0x3e
  158.         jc y1
  159.  
  160.         call esi
  161.  
  162.         shl ecx,1
  163.  
  164.         ret
  165. x1:
  166. y1:
  167.         nop
  168.  
  169.         fldcw word ptr [esp]
  170.  
  171.     }
  172. }
  173. #endif
  174.  
  175. ///////////////////////////////////////////////////////////////////////////
  176.  
  177. long symLookup(unsigned long virtAddr, char *buf, int buf_len) {
  178.     unsigned long offs;
  179.  
  180.     if ((offs = (virtAddr - (unsigned long)symLookup)) < 256) {
  181.         strcpy(buf, "symLookup");
  182.         return (long)offs;
  183.     }
  184.  
  185.     if ((offs = (virtAddr - (unsigned long)VDDisassemble)) < 256) {
  186.         strcpy(buf, "VDDisassemble");
  187.         return (long)offs;
  188.     }
  189.  
  190.     if ((offs = (virtAddr - (unsigned long)printf)) < 16) {
  191.         strcpy(buf, "printf");
  192.         return (long)offs;
  193.     }
  194.  
  195.     return -1;
  196. }
  197.  
  198. int main(int argc, char **argv) {
  199.     FILE *f = fopen(argc>1?argv[1]:"ia32.txt", "r");
  200.     parse_ia(g_RuleSystem, f);
  201.     fclose(f);
  202.  
  203. #if 0
  204.     std::vector<char> tr;
  205.     dump_tracedec(tr, g_RuleSystem);
  206.  
  207.     if (f = fopen(argc>2?argv[2]:"ia32trace.bin", "wb")) {
  208.         fwrite(&tr[0], tr.size(), 1, f);
  209.         fclose(f);
  210.     }
  211.  
  212.     std::vector<char> ruleTestHeap;
  213.     ruleTestHeap.resize(*(long *)&tr[68]);
  214.     void *dst_end = VDTracedecDecompress(&ruleTestHeap[0], (const unsigned char *)&tr[72], *(long *)&tr[64]);
  215.  
  216.     VDTracedecContext tdec;
  217.     tdec.pRuleSystem = (const unsigned char **)&ruleTestHeap[0];
  218.     tdec.physToVirtOffset = 0;
  219.  
  220.     void *src = (void *)0x401000;
  221.     VDTracedecResult res;
  222.  
  223.     std::set<ptrdiff_t> traces;
  224.     std::vector<ptrdiff_t> tracesToGo;
  225.  
  226.     tracesToGo.push_back((ptrdiff_t)0x401000);
  227.  
  228.     while(!tracesToGo.empty()) {
  229.         ptrdiff_t traceStart = tracesToGo.back();
  230.         tracesToGo.pop_back();
  231.  
  232.         printf("Tracing at %p\n", (void *)traceStart);
  233.         while(VDTraceObjectCode(&tdec, (const uint8 *)traceStart, 0xFFFFFF, res)) {
  234.             if (res.mbIsCall)
  235.                 printf("Call: %p\n", (void *)traceStart);
  236.             else if (res.mbIsJcc)
  237.                 printf("Jcc: %p\n", (void *)traceStart);
  238.             else if (res.mbIsJmp) {
  239.                 printf("Jmp: %p\n", (void *)traceStart);
  240.                 break;
  241.             } else if (res.mbIsReturn) {
  242.                 printf("Return: %p\n", (void *)traceStart);
  243.                 break;
  244.             }
  245.  
  246.             if (res.mbTargetValid) {
  247.                 ptrdiff_t newTrace = res.mBranchTarget;
  248.  
  249.                 if (traces.insert(newTrace).second)
  250.                     tracesToGo.push_back(newTrace);
  251.             }
  252.  
  253.             traceStart += res.mInsnLength;
  254.         }
  255.     }
  256. #else
  257.  
  258.     std::vector<char> dst;
  259.     dump_ia(dst, g_RuleSystem);
  260.  
  261.     if (f = fopen(argc>2?argv[2]:"ia32.bin", "wb")) {
  262.         fwrite(&dst[0], dst.size(), 1, f);
  263.         fclose(f);
  264.     }
  265.  
  266.     std::vector<char> ruleTestHeap;
  267.     ruleTestHeap.resize(*(long *)&dst[68]);
  268.     void *dst_end = VDDisasmDecompress(&ruleTestHeap[0], (const unsigned char *)&dst[72], *(long *)&dst[64]);
  269.  
  270.     VDDisassemblyContext vdc;
  271.  
  272.     vdc.pRuleSystem = (const unsigned char **)&ruleTestHeap[0];
  273.     vdc.pSymLookup = symLookup;
  274.     vdc.physToVirtOffset = 0;
  275.  
  276.     VDDisassemble(&vdc, (const uint8 *)test1, 1024);
  277. #endif
  278.  
  279.     _getch();
  280.  
  281.     return 0;
  282. }
  283.